home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 October: Mac OS SDK / Dev.CD Oct 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / AIncludes / MacMemory.a < prev    next >
Encoding:
Text File  |  1997-08-12  |  33.6 KB  |  1,408 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        MacMemory.a
  3. ;
  4. ;    Contains:    Memory Manager Interfaces.
  5. ;
  6. ;    Version:    Technology:    System 7.5
  7. ;                Release:    Universal Interfaces 3.0.1
  8. ;
  9. ;    Copyright:    © 1985-1997 by Apple Computer, Inc., all rights reserved
  10. ;
  11. ;    Bugs?:        Please include the the file and version information (from above) with
  12. ;                the problem description.  Developers belonging to one of the Apple
  13. ;                developer programs can submit bug reports to:
  14. ;
  15. ;                    devsupport@apple.com
  16. ;
  17. ;
  18.     IF &TYPE('__MACMEMORY__') = 'UNDEFINED' THEN
  19. __MACMEMORY__ SET 1
  20.  
  21.     IF &TYPE('__TYPES__') = 'UNDEFINED' THEN
  22.     include 'Types.a'
  23.     ENDIF
  24.     IF &TYPE('__MIXEDMODE__') = 'UNDEFINED' THEN
  25.     include 'MixedMode.a'
  26.     ENDIF
  27.  
  28.  
  29.  
  30. maxSize                            EQU        $00800000            ;Max data block size is 8 megabytes
  31.  
  32. defaultPhysicalEntryCount        EQU        8
  33.  
  34.                                                             ; values returned from the GetPageState function 
  35. kPageInMemory                    EQU        0
  36. kPageOnDisk                        EQU        1
  37. kNotPaged                        EQU        2
  38.  
  39.                                                             ; masks for Zone->heapType field 
  40. k32BitHeap                        EQU        1                    ; valid in all Memory Managers 
  41. kNewStyleHeap                    EQU        2                    ; true if new Heap Manager is present 
  42. kNewDebugHeap                    EQU        4                    ; true if new Heap Manager is running in debug mode on this heap 
  43. ;  Note: The type "Size" moved to Types.h 
  44.  
  45.  
  46. Zone                    RECORD 0
  47. bkLim                     ds.l    1                ; offset: $0 (0)
  48. purgePtr                 ds.l    1                ; offset: $4 (4)
  49. hFstFree                 ds.l    1                ; offset: $8 (8)
  50. zcbFree                     ds.l    1                ; offset: $C (12)
  51. gzProc                     ds.l    1                ; offset: $10 (16)
  52. moreMast                 ds.w    1                ; offset: $14 (20)
  53. flags                     ds.w    1                ; offset: $16 (22)
  54. cntRel                     ds.w    1                ; offset: $18 (24)
  55. maxRel                     ds.w    1                ; offset: $1A (26)
  56. cntNRel                     ds.w    1                ; offset: $1C (28)
  57. heapType                 ds.b    1                ; offset: $1E (30)        ;  previously "maxNRel", now holds flags (e.g. k32BitHeap)
  58. unused                     ds.b    1                ; offset: $1F (31)
  59. cntEmpty                 ds.w    1                ; offset: $20 (32)
  60. cntHandles                 ds.w    1                ; offset: $22 (34)
  61. minCBFree                 ds.l    1                ; offset: $24 (36)
  62. purgeProc                 ds.l    1                ; offset: $28 (40)
  63. sparePtr                 ds.l    1                ; offset: $2C (44)
  64. allocPtr                 ds.l    1                ; offset: $30 (48)
  65. heapData                 ds.w    1                ; offset: $34 (52)
  66. sizeof                     EQU *                    ; size:   $36 (54)
  67.                         ENDR
  68. ; typedef struct Zone *                    THz
  69.  
  70. MemoryBlock                RECORD 0
  71. address                     ds.l    1                ; offset: $0 (0)
  72. count                     ds.l    1                ; offset: $4 (4)
  73. sizeof                     EQU *                    ; size:   $8 (8)
  74.                         ENDR
  75. LogicalToPhysicalTable    RECORD 0
  76. logical                     ds        MemoryBlock        ; offset: $0 (0)
  77. physical                 ds.b    8 * MemoryBlock.sizeof ; offset: $8 (8)
  78. sizeof                     EQU *                    ; size:   $48 (72)
  79.                         ENDR
  80. ; typedef short                         PageState
  81.  
  82. ; typedef short                         StatusRegisterContents
  83.  
  84.  
  85.  
  86. ;
  87. ; pascal Ptr GetApplLimit(void)
  88. ;
  89.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  90.         Macro
  91.         _GetApplLimit         &dest=(sp)
  92.             move.l            $0130,&dest
  93.         EndM
  94.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  95.         IMPORT_CFM_FUNCTION GetApplLimit
  96.     ENDIF
  97.  
  98. ;
  99. ; pascal THz SystemZone(void)
  100. ;
  101.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  102.         Macro
  103.         _SystemZone           &dest=(sp)
  104.             move.l            $02A6,&dest
  105.         EndM
  106.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  107.         IMPORT_CFM_FUNCTION SystemZone
  108.     ENDIF
  109.  
  110. ;
  111. ; pascal THz ApplicationZone(void)
  112. ;
  113.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  114.         Macro
  115.         _ApplicationZone      &dest=(sp)
  116.             move.l            $02AA,&dest
  117.         EndM
  118.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  119.         IMPORT_CFM_FUNCTION ApplicationZone
  120.     ENDIF
  121.  
  122. ;
  123. ; pascal Handle GZSaveHnd(void)
  124. ;
  125.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  126.         Macro
  127.         _GZSaveHnd            &dest=(sp)
  128.             move.l            $0328,&dest
  129.         EndM
  130.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  131.         IMPORT_CFM_FUNCTION GZSaveHnd
  132.     ENDIF
  133.  
  134. ;
  135. ; pascal Ptr TopMem(void)
  136. ;
  137.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  138.         Macro
  139.         _TopMem               &dest=(sp)
  140.             move.l            $0108,&dest
  141.         EndM
  142.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  143.         IMPORT_CFM_FUNCTION TopMem
  144.     ENDIF
  145.  
  146. ;
  147. ; pascal OSErr MemError(void)
  148. ;
  149.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  150.         Macro
  151.         _MemError             &dest=(sp)
  152.             move.w            $0220,&dest
  153.         EndM
  154.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  155.         IMPORT_CFM_FUNCTION MemError
  156.     ENDIF
  157.  
  158.  
  159.  
  160. ;
  161. ; pascal THz GetZone(void )
  162. ;
  163.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  164.         ; returns:
  165.         ;    THz             <= A0
  166.         _GetZone:    OPWORD    $A11A
  167.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  168.         IMPORT_CFM_FUNCTION GetZone
  169.     ENDIF
  170.  
  171. ;
  172. ; pascal Handle NewHandle(Size byteCount)
  173. ;
  174.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  175.         ; parameters:
  176.         ;    byteCount       => D0
  177.         ; returns:
  178.         ;    Handle          <= A0
  179.         _NewHandle:    OPWORD    $A122
  180.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  181.         IMPORT_CFM_FUNCTION NewHandle
  182.     ENDIF
  183.  
  184. ;
  185. ; pascal Handle NewHandleSys(Size byteCount)
  186. ;
  187.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  188.         ; parameters:
  189.         ;    byteCount       => D0
  190.         ; returns:
  191.         ;    Handle          <= A0
  192.         _NewHandleSys:    OPWORD    $A522
  193.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  194.         IMPORT_CFM_FUNCTION NewHandleSys
  195.     ENDIF
  196.  
  197. ;
  198. ; pascal Handle NewHandleClear(Size byteCount)
  199. ;
  200.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  201.         ; parameters:
  202.         ;    byteCount       => D0
  203.         ; returns:
  204.         ;    Handle          <= A0
  205.         _NewHandleClear:    OPWORD    $A322
  206.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  207.         IMPORT_CFM_FUNCTION NewHandleClear
  208.     ENDIF
  209.  
  210. ;
  211. ; pascal Handle NewHandleSysClear(Size byteCount)
  212. ;
  213.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  214.         ; parameters:
  215.         ;    byteCount       => D0
  216.         ; returns:
  217.         ;    Handle          <= A0
  218.         _NewHandleSysClear:    OPWORD    $A722
  219.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  220.         IMPORT_CFM_FUNCTION NewHandleSysClear
  221.     ENDIF
  222.  
  223. ;
  224. ; pascal THz HandleZone(Handle h)
  225. ;
  226.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  227.         ; parameters:
  228.         ;    h               => A0
  229.         ; returns:
  230.         ;    THz             <= A0
  231.         _HandleZone:    OPWORD    $A126
  232.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  233.         IMPORT_CFM_FUNCTION HandleZone
  234.     ENDIF
  235.  
  236. ;
  237. ; pascal Handle RecoverHandle(Ptr p)
  238. ;
  239.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  240.         ; parameters:
  241.         ;    p               => A0
  242.         ; returns:
  243.         ;    Handle          <= A0
  244.         _RecoverHandle:    OPWORD    $A128
  245.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  246.         IMPORT_CFM_FUNCTION RecoverHandle
  247.     ENDIF
  248.  
  249. ;
  250. ; pascal Handle RecoverHandleSys(Ptr p)
  251. ;
  252.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  253.         ; parameters:
  254.         ;    p               => A0
  255.         ; returns:
  256.         ;    Handle          <= A0
  257.         _RecoverHandleSys:    OPWORD    $A528
  258.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  259.         IMPORT_CFM_FUNCTION RecoverHandleSys
  260.     ENDIF
  261.  
  262. ;
  263. ; pascal Ptr NewPtr(Size byteCount)
  264. ;
  265.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  266.         ; parameters:
  267.         ;    byteCount       => D0
  268.         ; returns:
  269.         ;    Ptr             <= A0
  270.         _NewPtr:    OPWORD    $A11E
  271.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  272.         IMPORT_CFM_FUNCTION NewPtr
  273.     ENDIF
  274.  
  275. ;
  276. ; pascal Ptr NewPtrSys(Size byteCount)
  277. ;
  278.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  279.         ; parameters:
  280.         ;    byteCount       => D0
  281.         ; returns:
  282.         ;    Ptr             <= A0
  283.         _NewPtrSys:    OPWORD    $A51E
  284.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  285.         IMPORT_CFM_FUNCTION NewPtrSys
  286.     ENDIF
  287.  
  288. ;
  289. ; pascal Ptr NewPtrClear(Size byteCount)
  290. ;
  291.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  292.         ; parameters:
  293.         ;    byteCount       => D0
  294.         ; returns:
  295.         ;    Ptr             <= A0
  296.         _NewPtrClear:    OPWORD    $A31E
  297.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  298.         IMPORT_CFM_FUNCTION NewPtrClear
  299.     ENDIF
  300.  
  301. ;
  302. ; pascal Ptr NewPtrSysClear(Size byteCount)
  303. ;
  304.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  305.         ; parameters:
  306.         ;    byteCount       => D0
  307.         ; returns:
  308.         ;    Ptr             <= A0
  309.         _NewPtrSysClear:    OPWORD    $A71E
  310.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  311.         IMPORT_CFM_FUNCTION NewPtrSysClear
  312.     ENDIF
  313.  
  314. ;
  315. ; pascal THz PtrZone(Ptr p)
  316. ;
  317.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  318.         ; parameters:
  319.         ;    p               => A0
  320.         ; returns:
  321.         ;    THz             <= A0
  322.         _PtrZone:    OPWORD    $A148
  323.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  324.         IMPORT_CFM_FUNCTION PtrZone
  325.     ENDIF
  326.  
  327. ;
  328. ; pascal long MaxBlock(void )
  329. ;
  330.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  331.         ; returns:
  332.         ;    long            <= D0
  333.         _MaxBlock:    OPWORD    $A061
  334.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  335.         IMPORT_CFM_FUNCTION MaxBlock
  336.     ENDIF
  337.  
  338. ;
  339. ; pascal long MaxBlockSys(void )
  340. ;
  341.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  342.         ; returns:
  343.         ;    long            <= D0
  344.         _MaxBlockSys:    OPWORD    $A461
  345.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  346.         IMPORT_CFM_FUNCTION MaxBlockSys
  347.     ENDIF
  348.  
  349. ;
  350. ; pascal long StackSpace(void )
  351. ;
  352.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  353.         ; returns:
  354.         ;    long            <= D0
  355.         _StackSpace:    OPWORD    $A065
  356.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  357.         IMPORT_CFM_FUNCTION StackSpace
  358.     ENDIF
  359.  
  360. ;
  361. ; pascal Handle NewEmptyHandle(void )
  362. ;
  363.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  364.         ; returns:
  365.         ;    Handle          <= A0
  366.         _NewEmptyHandle:    OPWORD    $A166
  367.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  368.         IMPORT_CFM_FUNCTION NewEmptyHandle
  369.     ENDIF
  370.  
  371. ;
  372. ; pascal Handle NewEmptyHandleSys(void )
  373. ;
  374.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  375.         ; returns:
  376.         ;    Handle          <= A0
  377.         _NewEmptyHandleSys:    OPWORD    $A566
  378.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  379.         IMPORT_CFM_FUNCTION NewEmptyHandleSys
  380.     ENDIF
  381.  
  382. ;
  383. ; pascal void HLock(Handle h)
  384. ;
  385.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  386.         ; parameters:
  387.         ;    h               => A0
  388.         _HLock:    OPWORD    $A029
  389.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  390.         IMPORT_CFM_FUNCTION HLock
  391.     ENDIF
  392.  
  393. ;
  394. ; pascal void HUnlock(Handle h)
  395. ;
  396.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  397.         ; parameters:
  398.         ;    h               => A0
  399.         _HUnlock:    OPWORD    $A02A
  400.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  401.         IMPORT_CFM_FUNCTION HUnlock
  402.     ENDIF
  403.  
  404. ;
  405. ; pascal void HPurge(Handle h)
  406. ;
  407.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  408.         ; parameters:
  409.         ;    h               => A0
  410.         _HPurge:    OPWORD    $A049
  411.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  412.         IMPORT_CFM_FUNCTION HPurge
  413.     ENDIF
  414.  
  415. ;
  416. ; pascal void HNoPurge(Handle h)
  417. ;
  418.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  419.         ; parameters:
  420.         ;    h               => A0
  421.         _HNoPurge:    OPWORD    $A04A
  422.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  423.         IMPORT_CFM_FUNCTION HNoPurge
  424.     ENDIF
  425.  
  426. ;
  427. ; pascal void HLockHi(Handle h)
  428. ;
  429.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  430.         ; parameters:
  431.         ;    h               => A0
  432.         Macro
  433.         _HLockHi
  434.             dc.w                $A064
  435.             dc.w                $A029
  436.         EndM
  437.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  438.         IMPORT_CFM_FUNCTION HLockHi
  439.     ENDIF
  440.  
  441. ;
  442. ; pascal Handle TempNewHandle(Size logicalSize, OSErr *resultCode)
  443. ;
  444.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  445.         Macro
  446.         _TempNewHandle
  447.             move.w              #$001D,-(sp)
  448.             dc.w                $A88F
  449.         EndM
  450.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  451.         IMPORT_CFM_FUNCTION TempNewHandle
  452.     ENDIF
  453.  
  454. ;
  455. ; pascal Size TempMaxMem(Size *grow)
  456. ;
  457.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  458.         Macro
  459.         _TempMaxMem
  460.             move.w              #$0015,-(sp)
  461.             dc.w                $A88F
  462.         EndM
  463.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  464.         IMPORT_CFM_FUNCTION TempMaxMem
  465.     ENDIF
  466.  
  467. ;
  468. ; pascal long TempFreeMem(void )
  469. ;
  470.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  471.         Macro
  472.         _TempFreeMem
  473.             move.w              #$0018,-(sp)
  474.             dc.w                $A88F
  475.         EndM
  476.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  477.         IMPORT_CFM_FUNCTION TempFreeMem
  478.     ENDIF
  479.  
  480. ;
  481. ; pascal void InitZone(GrowZoneUPP pgrowZone, short cmoreMasters, void *limitPtr, void *startPtr)
  482. ;
  483.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  484.         _InitZone:    OPWORD    $A019
  485.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  486.         IMPORT_CFM_FUNCTION InitZone
  487.     ENDIF
  488.  
  489. ;
  490. ; pascal void SetZone(THz hz)
  491. ;
  492.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  493.         ; parameters:
  494.         ;    hz              => A0
  495.         _SetZone:    OPWORD    $A01B
  496.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  497.         IMPORT_CFM_FUNCTION SetZone
  498.     ENDIF
  499.  
  500. ;
  501. ; pascal Size CompactMem(Size cbNeeded)
  502. ;
  503.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  504.         ; parameters:
  505.         ;    cbNeeded        => D0
  506.         ; returns:
  507.         ;    Size            <= D0
  508.         _CompactMem:    OPWORD    $A04C
  509.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  510.         IMPORT_CFM_FUNCTION CompactMem
  511.     ENDIF
  512.  
  513. ;
  514. ; pascal Size CompactMemSys(Size cbNeeded)
  515. ;
  516.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  517.         ; parameters:
  518.         ;    cbNeeded        => D0
  519.         ; returns:
  520.         ;    Size            <= D0
  521.         _CompactMemSys:    OPWORD    $A44C
  522.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  523.         IMPORT_CFM_FUNCTION CompactMemSys
  524.     ENDIF
  525.  
  526. ;
  527. ; pascal void PurgeMem(Size cbNeeded)
  528. ;
  529.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  530.         ; parameters:
  531.         ;    cbNeeded        => D0
  532.         _PurgeMem:    OPWORD    $A04D
  533.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  534.         IMPORT_CFM_FUNCTION PurgeMem
  535.     ENDIF
  536.  
  537. ;
  538. ; pascal void PurgeMemSys(Size cbNeeded)
  539. ;
  540.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  541.         ; parameters:
  542.         ;    cbNeeded        => D0
  543.         _PurgeMemSys:    OPWORD    $A44D
  544.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  545.         IMPORT_CFM_FUNCTION PurgeMemSys
  546.     ENDIF
  547.  
  548. ;
  549. ; pascal long FreeMem(void )
  550. ;
  551.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  552.         ; returns:
  553.         ;    long            <= D0
  554.         _FreeMem:    OPWORD    $A01C
  555.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  556.         IMPORT_CFM_FUNCTION FreeMem
  557.     ENDIF
  558.  
  559. ;
  560. ; pascal long FreeMemSys(void )
  561. ;
  562.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  563.         ; returns:
  564.         ;    long            <= D0
  565.         _FreeMemSys:    OPWORD    $A41C
  566.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  567.         IMPORT_CFM_FUNCTION FreeMemSys
  568.     ENDIF
  569.  
  570. ;
  571. ; pascal void ReserveMem(Size cbNeeded)
  572. ;
  573.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  574.         ; parameters:
  575.         ;    cbNeeded        => D0
  576.         _ReserveMem:    OPWORD    $A040
  577.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  578.         IMPORT_CFM_FUNCTION ReserveMem
  579.     ENDIF
  580.  
  581. ;
  582. ; pascal void ReserveMemSys(Size cbNeeded)
  583. ;
  584.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  585.         ; parameters:
  586.         ;    cbNeeded        => D0
  587.         _ReserveMemSys:    OPWORD    $A440
  588.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  589.         IMPORT_CFM_FUNCTION ReserveMemSys
  590.     ENDIF
  591.  
  592. ;
  593. ; pascal Size MaxMem(Size *grow)
  594. ;
  595.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  596.         _MaxMem:    OPWORD    $A11D
  597.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  598.         IMPORT_CFM_FUNCTION MaxMem
  599.     ENDIF
  600.  
  601. ;
  602. ; pascal Size MaxMemSys(Size *grow)
  603. ;
  604.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  605.         _MaxMemSys:    OPWORD    $A51D
  606.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  607.         IMPORT_CFM_FUNCTION MaxMemSys
  608.     ENDIF
  609.  
  610. ;
  611. ; pascal void SetGrowZone(GrowZoneUPP growZone)
  612. ;
  613.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  614.         ; parameters:
  615.         ;    growZone        => A0
  616.         _SetGrowZone:    OPWORD    $A04B
  617.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  618.         IMPORT_CFM_FUNCTION SetGrowZone
  619.     ENDIF
  620.  
  621. ;
  622. ; pascal void MoveHHi(Handle h)
  623. ;
  624.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  625.         ; parameters:
  626.         ;    h               => A0
  627.         _MoveHHi:    OPWORD    $A064
  628.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  629.         IMPORT_CFM_FUNCTION MoveHHi
  630.     ENDIF
  631.  
  632. ;
  633. ; pascal void DisposePtr(Ptr p)
  634. ;
  635.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  636.         ; parameters:
  637.         ;    p               => A0
  638.         _DisposePtr:    OPWORD    $A01F
  639.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  640.         IMPORT_CFM_FUNCTION DisposePtr
  641.     ENDIF
  642.  
  643. ;
  644. ; pascal Size GetPtrSize(Ptr p)
  645. ;
  646.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  647.         _GetPtrSize:    OPWORD    $A021
  648.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  649.         IMPORT_CFM_FUNCTION GetPtrSize
  650.     ENDIF
  651.  
  652. ;
  653. ; pascal void SetPtrSize(Ptr p, Size newSize)
  654. ;
  655.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  656.         ; parameters:
  657.         ;    p               => A0
  658.         ;    newSize         => D0
  659.         _SetPtrSize:    OPWORD    $A020
  660.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  661.         IMPORT_CFM_FUNCTION SetPtrSize
  662.     ENDIF
  663.  
  664. ;
  665. ; pascal void DisposeHandle(Handle h)
  666. ;
  667.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  668.         ; parameters:
  669.         ;    h               => A0
  670.         _DisposeHandle:    OPWORD    $A023
  671.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  672.         IMPORT_CFM_FUNCTION DisposeHandle
  673.     ENDIF
  674.  
  675. ;
  676. ; pascal void SetHandleSize(Handle h, Size newSize)
  677. ;
  678.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  679.         ; parameters:
  680.         ;    h               => A0
  681.         ;    newSize         => D0
  682.         _SetHandleSize:    OPWORD    $A024
  683.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  684.         IMPORT_CFM_FUNCTION SetHandleSize
  685.     ENDIF
  686.  
  687. ;  
  688. ;    NOTE
  689. ;    
  690. ;    GetHandleSize and GetPtrSize are documented in Inside Mac as returning 0 
  691. ;    in case of an error, but the traps actually return an error code in D0.
  692. ;    The glue sets D0 to 0 if an error occured.
  693. ;
  694.  
  695. ;
  696. ; pascal Size GetHandleSize(Handle h)
  697. ;
  698.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  699.         _GetHandleSize:    OPWORD    $A025
  700.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  701.         IMPORT_CFM_FUNCTION GetHandleSize
  702.     ENDIF
  703.  
  704. ;
  705. ; pascal Size InlineGetHandleSize(Handle h)
  706. ;
  707.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  708.         ; parameters:
  709.         ;    h               => A0
  710.         ; returns:
  711.         ;    Size            <= D0
  712.         _InlineGetHandleSize:    OPWORD    $A025
  713.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  714.         IMPORT_CFM_FUNCTION InlineGetHandleSize
  715.     ENDIF
  716.  
  717. ;
  718. ; pascal void ReallocateHandle(Handle h, Size byteCount)
  719. ;
  720.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  721.         ; parameters:
  722.         ;    h               => A0
  723.         ;    byteCount       => D0
  724.         _ReallocateHandle:    OPWORD    $A027
  725.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  726.         IMPORT_CFM_FUNCTION ReallocateHandle
  727.     ENDIF
  728.  
  729. ;
  730. ; pascal void ReallocateHandleSys(Handle h, Size byteCount)
  731. ;
  732.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  733.         ; parameters:
  734.         ;    h               => A0
  735.         ;    byteCount       => D0
  736.         _ReallocateHandleSys:    OPWORD    $A427
  737.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  738.         IMPORT_CFM_FUNCTION ReallocateHandleSys
  739.     ENDIF
  740.  
  741. ;
  742. ; pascal void EmptyHandle(Handle h)
  743. ;
  744.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  745.         ; parameters:
  746.         ;    h               => A0
  747.         _EmptyHandle:    OPWORD    $A02B
  748.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  749.         IMPORT_CFM_FUNCTION EmptyHandle
  750.     ENDIF
  751.  
  752. ;
  753. ; pascal void HSetRBit(Handle h)
  754. ;
  755.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  756.         ; parameters:
  757.         ;    h               => A0
  758.         _HSetRBit:    OPWORD    $A067
  759.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  760.         IMPORT_CFM_FUNCTION HSetRBit
  761.     ENDIF
  762.  
  763. ;
  764. ; pascal void HClrRBit(Handle h)
  765. ;
  766.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  767.         ; parameters:
  768.         ;    h               => A0
  769.         _HClrRBit:    OPWORD    $A068
  770.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  771.         IMPORT_CFM_FUNCTION HClrRBit
  772.     ENDIF
  773.  
  774. ;
  775. ; pascal SInt8 HGetState(Handle h)
  776. ;
  777.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  778.         ; parameters:
  779.         ;    h               => A0
  780.         ; returns:
  781.         ;    SInt8           <= D0
  782.         _HGetState:    OPWORD    $A069
  783.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  784.         IMPORT_CFM_FUNCTION HGetState
  785.     ENDIF
  786.  
  787. ;
  788. ; pascal void HSetState(Handle h, SInt8 flags)
  789. ;
  790.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  791.         ; parameters:
  792.         ;    h               => A0
  793.         ;    flags           => D0
  794.         _HSetState:    OPWORD    $A06A
  795.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  796.         IMPORT_CFM_FUNCTION HSetState
  797.     ENDIF
  798.  
  799. ;
  800. ; pascal void PurgeSpace(long *total, long *contig)
  801. ;
  802.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  803.         _PurgeSpace:    OPWORD    $A162
  804.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  805.         IMPORT_CFM_FUNCTION PurgeSpace
  806.     ENDIF
  807.  
  808.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  809. ; 
  810. ;    PurgeSpaceTotal and PurgeSpaceContiguous are currently only implement
  811. ;    on classic 68K.  The are the same as PurgeSpace() but return just
  812. ;    one value (either total space purgable or contiguous space purgable).
  813. ;
  814.  
  815. ;
  816. ; pascal long PurgeSpaceTotal(void )
  817. ;
  818.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  819.         ; returns:
  820.         ;    long            <= A0
  821.         _PurgeSpaceTotal:    OPWORD    $A062
  822.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  823.         IMPORT_CFM_FUNCTION PurgeSpaceTotal
  824.     ENDIF
  825.  
  826. ;
  827. ; pascal long PurgeSpaceContiguous(void )
  828. ;
  829.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  830.         ; returns:
  831.         ;    long            <= D0
  832.         _PurgeSpaceContiguous:    OPWORD    $A062
  833.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  834.         IMPORT_CFM_FUNCTION PurgeSpaceContiguous
  835.     ENDIF
  836.  
  837. ;
  838. ; pascal long PurgeSpaceSysTotal(void )
  839. ;
  840.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  841.         ; returns:
  842.         ;    long            <= A0
  843.         _PurgeSpaceSysTotal:    OPWORD    $A562
  844.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  845.         IMPORT_CFM_FUNCTION PurgeSpaceSysTotal
  846.     ENDIF
  847.  
  848. ;
  849. ; pascal long PurgeSpaceSysContiguous(void )
  850. ;
  851.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  852.         ; returns:
  853.         ;    long            <= D0
  854.         _PurgeSpaceSysContiguous:    OPWORD    $A562
  855.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  856.         IMPORT_CFM_FUNCTION PurgeSpaceSysContiguous
  857.     ENDIF
  858.  
  859.     ENDIF
  860. ; *****************************************************************************
  861. ;
  862. ;    The routines: 
  863. ;
  864. ;        BlockMoveUncached
  865. ;        BlockMoveDataUncached
  866. ;        BlockZero
  867. ;        BlockZeroUncached
  868. ;    
  869. ;    are intended for developers writing drivers. They do not exist in 
  870. ;    “InterfaceLib.” You must link with “DriverServicesLib” to access them.
  871. ;    
  872. ;    But since BlockMove and BlockMoveData exist in both “InterfaceLib” and
  873. ;    “DriverServicesLib”, you cannot link with both libraries.
  874. ;    
  875. ;****************************************************************************
  876.  
  877. ;
  878. ; pascal void BlockMove(const void *srcPtr, void *destPtr, Size byteCount)
  879. ;
  880.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  881.         ; parameters:
  882.         ;    srcPtr          => A0
  883.         ;    destPtr         => A1
  884.         ;    byteCount       => D0
  885.         _BlockMove:    OPWORD    $A02E
  886.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  887.         IMPORT_CFM_FUNCTION BlockMove
  888.     ENDIF
  889.  
  890. ;
  891. ; pascal void BlockMoveData(const void *srcPtr, void *destPtr, Size byteCount)
  892. ;
  893.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  894.         ; parameters:
  895.         ;    srcPtr          => A0
  896.         ;    destPtr         => A1
  897.         ;    byteCount       => D0
  898.         _BlockMoveData:    OPWORD    $A22E
  899.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  900.         IMPORT_CFM_FUNCTION BlockMoveData
  901.     ENDIF
  902.  
  903. ;
  904. ; extern void BlockMoveUncached(const void *srcPtr, void *destPtr, Size byteCount)
  905. ;
  906.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  907.         IMPORT_CFM_FUNCTION BlockMoveUncached
  908.     ENDIF
  909.  
  910. ;
  911. ; extern void BlockMoveDataUncached(const void *srcPtr, void *destPtr, Size byteCount)
  912. ;
  913.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  914.         IMPORT_CFM_FUNCTION BlockMoveDataUncached
  915.     ENDIF
  916.  
  917. ;
  918. ; extern void BlockZero(void *destPtr, Size byteCount)
  919. ;
  920.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  921.         IMPORT_CFM_FUNCTION BlockZero
  922.     ENDIF
  923.  
  924. ;
  925. ; extern void BlockZeroUncached(void *destPtr, Size byteCount)
  926. ;
  927.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  928.         IMPORT_CFM_FUNCTION BlockZeroUncached
  929.     ENDIF
  930.  
  931.  
  932. ;
  933. ; pascal void MaxApplZone(void )
  934. ;
  935.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  936.         _MaxApplZone:    OPWORD    $A063
  937.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  938.         IMPORT_CFM_FUNCTION MaxApplZone
  939.     ENDIF
  940.  
  941. ;
  942. ; pascal void SetApplBase(void *startPtr)
  943. ;
  944.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  945.         ; parameters:
  946.         ;    startPtr        => A0
  947.         _SetApplBase:    OPWORD    $A057
  948.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  949.         IMPORT_CFM_FUNCTION SetApplBase
  950.     ENDIF
  951.  
  952. ;
  953. ; pascal void MoreMasters(void )
  954. ;
  955.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  956.         _MoreMasters:    OPWORD    $A036
  957.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  958.         IMPORT_CFM_FUNCTION MoreMasters
  959.     ENDIF
  960.  
  961. ;
  962. ; pascal void SetApplLimit(void *zoneLimit)
  963. ;
  964.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  965.         ; parameters:
  966.         ;    zoneLimit       => A0
  967.         _SetApplLimit:    OPWORD    $A02D
  968.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  969.         IMPORT_CFM_FUNCTION SetApplLimit
  970.     ENDIF
  971.  
  972.  
  973.  
  974. ;
  975. ; pascal void InitApplZone(void )
  976. ;
  977.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  978.         _InitApplZone:    OPWORD    $A02C
  979.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  980.         IMPORT_CFM_FUNCTION InitApplZone
  981.     ENDIF
  982.  
  983.  
  984. ;   Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  
  985. ;
  986. ; pascal void TempHLock(Handle h, OSErr *resultCode)
  987. ;
  988.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  989.         Macro
  990.         _TempHLock
  991.             move.w              #$001E,-(sp)
  992.             dc.w                $A88F
  993.         EndM
  994.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  995.         IMPORT_CFM_FUNCTION TempHLock
  996.     ENDIF
  997.  
  998. ;
  999. ; pascal void TempHUnlock(Handle h, OSErr *resultCode)
  1000. ;
  1001.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1002.         Macro
  1003.         _TempHUnlock
  1004.             move.w              #$001F,-(sp)
  1005.             dc.w                $A88F
  1006.         EndM
  1007.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1008.         IMPORT_CFM_FUNCTION TempHUnlock
  1009.     ENDIF
  1010.  
  1011. ;
  1012. ; pascal void TempDisposeHandle(Handle h, OSErr *resultCode)
  1013. ;
  1014.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1015.         Macro
  1016.         _TempDisposeHandle
  1017.             move.w              #$0020,-(sp)
  1018.             dc.w                $A88F
  1019.         EndM
  1020.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1021.         IMPORT_CFM_FUNCTION TempDisposeHandle
  1022.     ENDIF
  1023.  
  1024. ;
  1025. ; pascal Ptr TempTopMem(void )
  1026. ;
  1027.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1028.         Macro
  1029.         _TempTopMem
  1030.             move.w              #$0016,-(sp)
  1031.             dc.w                $A88F
  1032.         EndM
  1033.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1034.         IMPORT_CFM_FUNCTION TempTopMem
  1035.     ENDIF
  1036.  
  1037. ;
  1038. ; pascal OSErr HoldMemory(void *address, unsigned long count)
  1039. ;
  1040.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1041.         ; parameters:
  1042.         ;    address         => A0
  1043.         ;    count           => A1
  1044.         ; returns:
  1045.         ;    OSErr           <= D0
  1046.         Macro
  1047.         _HoldMemory
  1048.             moveq               #0,D0
  1049.             dc.w                $A05C
  1050.         EndM
  1051.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1052.         IMPORT_CFM_FUNCTION HoldMemory
  1053.     ENDIF
  1054.  
  1055. ;
  1056. ; pascal OSErr UnholdMemory(void *address, unsigned long count)
  1057. ;
  1058.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1059.         ; parameters:
  1060.         ;    address         => A0
  1061.         ;    count           => A1
  1062.         ; returns:
  1063.         ;    OSErr           <= D0
  1064.         Macro
  1065.         _UnholdMemory
  1066.             moveq               #1,D0
  1067.             dc.w                $A05C
  1068.         EndM
  1069.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1070.         IMPORT_CFM_FUNCTION UnholdMemory
  1071.     ENDIF
  1072.  
  1073. ;
  1074. ; pascal OSErr LockMemory(void *address, unsigned long count)
  1075. ;
  1076.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1077.         ; parameters:
  1078.         ;    address         => A0
  1079.         ;    count           => A1
  1080.         ; returns:
  1081.         ;    OSErr           <= D0
  1082.         Macro
  1083.         _LockMemory
  1084.             moveq               #2,D0
  1085.             dc.w                $A05C
  1086.         EndM
  1087.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1088.         IMPORT_CFM_FUNCTION LockMemory
  1089.     ENDIF
  1090.  
  1091. ;
  1092. ; pascal OSErr LockMemoryForOutput(void *address, unsigned long count)
  1093. ;
  1094.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1095.         ; parameters:
  1096.         ;    address         => A0
  1097.         ;    count           => A1
  1098.         ; returns:
  1099.         ;    OSErr           <= D0
  1100.         Macro
  1101.         _LockMemoryForOutput
  1102.             moveq               #10,D0
  1103.             dc.w                $A05C
  1104.         EndM
  1105.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1106.         IMPORT_CFM_FUNCTION LockMemoryForOutput
  1107.     ENDIF
  1108.  
  1109. ;
  1110. ; pascal OSErr LockMemoryContiguous(void *address, unsigned long count)
  1111. ;
  1112.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1113.         ; parameters:
  1114.         ;    address         => A0
  1115.         ;    count           => A1
  1116.         ; returns:
  1117.         ;    OSErr           <= D0
  1118.         Macro
  1119.         _LockMemoryContiguous
  1120.             moveq               #4,D0
  1121.             dc.w                $A05C
  1122.         EndM
  1123.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1124.         IMPORT_CFM_FUNCTION LockMemoryContiguous
  1125.     ENDIF
  1126.  
  1127. ;
  1128. ; pascal OSErr UnlockMemory(void *address, unsigned long count)
  1129. ;
  1130.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1131.         ; parameters:
  1132.         ;    address         => A0
  1133.         ;    count           => A1
  1134.         ; returns:
  1135.         ;    OSErr           <= D0
  1136.         Macro
  1137.         _UnlockMemory
  1138.             moveq               #3,D0
  1139.             dc.w                $A05C
  1140.         EndM
  1141.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1142.         IMPORT_CFM_FUNCTION UnlockMemory
  1143.     ENDIF
  1144.  
  1145. ;
  1146. ; pascal OSErr GetPhysical(LogicalToPhysicalTable *addresses, unsigned long *physicalEntryCount)
  1147. ;
  1148.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1149.         Macro
  1150.         _GetPhysical
  1151.             moveq               #5,D0
  1152.             dc.w                $A05C
  1153.         EndM
  1154.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1155.         IMPORT_CFM_FUNCTION GetPhysical
  1156.     ENDIF
  1157.  
  1158. ;
  1159. ; pascal OSErr DeferUserFn(UserFnUPP userFunction, void *argument)
  1160. ;
  1161.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1162.         ; parameters:
  1163.         ;    userFunctionargument=> A0
  1164.         ;    argument        => D0
  1165.         ; returns:
  1166.         ;    OSErr           <= D0
  1167.         _DeferUserFn:    OPWORD    $A08F
  1168.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1169.         IMPORT_CFM_FUNCTION DeferUserFn
  1170.     ENDIF
  1171.  
  1172. ;
  1173. ; pascal long DebuggerGetMax(void )
  1174. ;
  1175.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1176.         ; returns:
  1177.         ;    long            <= D0
  1178.         Macro
  1179.         _DebuggerGetMax
  1180.             moveq               #0,D0
  1181.             dc.w                $A08D
  1182.         EndM
  1183.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1184.         IMPORT_CFM_FUNCTION DebuggerGetMax
  1185.     ENDIF
  1186.  
  1187. ;
  1188. ; pascal void DebuggerEnter(void )
  1189. ;
  1190.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1191.         Macro
  1192.         _DebuggerEnter
  1193.             moveq               #1,D0
  1194.             dc.w                $A08D
  1195.         EndM
  1196.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1197.         IMPORT_CFM_FUNCTION DebuggerEnter
  1198.     ENDIF
  1199.  
  1200. ;
  1201. ; pascal void DebuggerExit(void )
  1202. ;
  1203.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1204.         Macro
  1205.         _DebuggerExit
  1206.             moveq               #2,D0
  1207.             dc.w                $A08D
  1208.         EndM
  1209.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1210.         IMPORT_CFM_FUNCTION DebuggerExit
  1211.     ENDIF
  1212.  
  1213. ;
  1214. ; pascal void DebuggerPoll(void )
  1215. ;
  1216.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1217.         Macro
  1218.         _DebuggerPoll
  1219.             moveq               #3,D0
  1220.             dc.w                $A08D
  1221.         EndM
  1222.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1223.         IMPORT_CFM_FUNCTION DebuggerPoll
  1224.     ENDIF
  1225.  
  1226. ;
  1227. ; pascal PageState GetPageState(const void *address)
  1228. ;
  1229.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1230.         ; parameters:
  1231.         ;    address         => A0
  1232.         ; returns:
  1233.         ;    PageState       <= D0
  1234.         Macro
  1235.         _GetPageState
  1236.             moveq               #4,D0
  1237.             dc.w                $A08D
  1238.         EndM
  1239.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1240.         IMPORT_CFM_FUNCTION GetPageState
  1241.     ENDIF
  1242.  
  1243. ;
  1244. ; pascal Boolean PageFaultFatal(void )
  1245. ;
  1246.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1247.         ; returns:
  1248.         ;    Boolean         <= D0
  1249.         Macro
  1250.         _PageFaultFatal
  1251.             moveq               #5,D0
  1252.             dc.w                $A08D
  1253.         EndM
  1254.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1255.         IMPORT_CFM_FUNCTION PageFaultFatal
  1256.     ENDIF
  1257.  
  1258. ;
  1259. ; pascal OSErr DebuggerLockMemory(void *address, unsigned long count)
  1260. ;
  1261.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1262.         ; parameters:
  1263.         ;    address         => A0
  1264.         ;    count           => A1
  1265.         ; returns:
  1266.         ;    OSErr           <= D0
  1267.         Macro
  1268.         _DebuggerLockMemory
  1269.             moveq               #6,D0
  1270.             dc.w                $A08D
  1271.         EndM
  1272.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1273.         IMPORT_CFM_FUNCTION DebuggerLockMemory
  1274.     ENDIF
  1275.  
  1276. ;
  1277. ; pascal OSErr DebuggerUnlockMemory(void *address, unsigned long count)
  1278. ;
  1279.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1280.         ; parameters:
  1281.         ;    address         => A0
  1282.         ;    count           => A1
  1283.         ; returns:
  1284.         ;    OSErr           <= D0
  1285.         Macro
  1286.         _DebuggerUnlockMemory
  1287.             moveq               #7,D0
  1288.             dc.w                $A08D
  1289.         EndM
  1290.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1291.         IMPORT_CFM_FUNCTION DebuggerUnlockMemory
  1292.     ENDIF
  1293.  
  1294. ;
  1295. ; pascal StatusRegisterContents EnterSupervisorMode(void )
  1296. ;
  1297.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1298.         ; returns:
  1299.         ;    StatusRegisterContents <= D0
  1300.         Macro
  1301.         _EnterSupervisorMode
  1302.             moveq               #8,D0
  1303.             dc.w                $A08D
  1304.         EndM
  1305.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1306.         IMPORT_CFM_FUNCTION EnterSupervisorMode
  1307.     ENDIF
  1308.  
  1309.  
  1310. ;  
  1311. ;    StripAddress and Translate24To32 are traps on classic 68K,
  1312. ;    but macro to the identity function on PowerMacs or other OS's.
  1313. ;
  1314.  
  1315. ;
  1316. ; pascal Ptr StripAddress(void *theAddress)
  1317. ;
  1318.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1319.         ; parameters:
  1320.         ;    theAddress      => D0
  1321.         ; returns:
  1322.         ;    Ptr             <= D0
  1323.         _StripAddress:    OPWORD    $A055
  1324.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1325.         IMPORT_CFM_FUNCTION StripAddress
  1326.     ENDIF
  1327.  
  1328.  
  1329. ;
  1330. ; pascal Ptr Translate24To32(void *addr24)
  1331. ;
  1332.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1333.         ; parameters:
  1334.         ;    addr24          => D0
  1335.         ; returns:
  1336.         ;    Ptr             <= D0
  1337.         _Translate24To32:    OPWORD    $A091
  1338.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1339.         IMPORT_CFM_FUNCTION Translate24To32
  1340.     ENDIF
  1341.  
  1342. ;
  1343. ; pascal OSErr HandToHand(Handle *theHndl)
  1344. ;
  1345.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1346.         _HandToHand:    OPWORD    $A9E1
  1347.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1348.         IMPORT_CFM_FUNCTION HandToHand
  1349.     ENDIF
  1350.  
  1351. ;
  1352. ; pascal OSErr PtrToXHand(const void *srcPtr, Handle dstHndl, long size)
  1353. ;
  1354.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1355.         ; parameters:
  1356.         ;    srcPtr          => A0
  1357.         ;    dstHndl         => A1
  1358.         ;    size            => D0
  1359.         ; returns:
  1360.         ;    OSErr           <= D0
  1361.         _PtrToXHand:    OPWORD    $A9E2
  1362.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1363.         IMPORT_CFM_FUNCTION PtrToXHand
  1364.     ENDIF
  1365.  
  1366. ;
  1367. ; pascal OSErr PtrToHand(const void *srcPtr, Handle *dstHndl, long size)
  1368. ;
  1369.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1370.         _PtrToHand:    OPWORD    $A9E3
  1371.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1372.         IMPORT_CFM_FUNCTION PtrToHand
  1373.     ENDIF
  1374.  
  1375. ;
  1376. ; pascal OSErr HandAndHand(Handle hand1, Handle hand2)
  1377. ;
  1378.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1379.         ; parameters:
  1380.         ;    hand1           => A0
  1381.         ;    hand2           => A1
  1382.         ; returns:
  1383.         ;    OSErr           <= D0
  1384.         _HandAndHand:    OPWORD    $A9E4
  1385.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1386.         IMPORT_CFM_FUNCTION HandAndHand
  1387.     ENDIF
  1388.  
  1389. ;
  1390. ; pascal OSErr PtrAndHand(const void *ptr1, Handle hand2, long size)
  1391. ;
  1392.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1393.         ; parameters:
  1394.         ;    ptr1            => A0
  1395.         ;    hand2           => A1
  1396.         ;    size            => D0
  1397.         ; returns:
  1398.         ;    OSErr           <= D0
  1399.         _PtrAndHand:    OPWORD    $A9EF
  1400.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1401.         IMPORT_CFM_FUNCTION PtrAndHand
  1402.     ENDIF
  1403.  
  1404.     IF OLDROUTINENAMES THEN
  1405.     ENDIF    ; OLDROUTINENAMES
  1406.     ENDIF ; __MACMEMORY__ 
  1407.  
  1408.